package com.tusuo.stds.ui.school;

import android.content.Context;
import android.os.Build;
import android.text.TextUtils;

import com.baidu.location.BDLocation;
import com.baidu.location.BDLocationListener;
import com.baidu.location.LocationClient;
import com.baidu.location.LocationClientOption;
import com.hannesdorfmann.mosby.mvp.MvpBasePresenter;
import com.tusuo.stds.MyApp;
import com.tusuo.stds.R;
import com.tusuo.stds.biz.CurrentUser;
import com.tusuo.stds.di.DaggerScope;
import com.tusuo.stds.di.Injector;
import com.tusuo.stds.rest.ApiHelper;
import com.tusuo.stds.rest.AreaList;
import com.tusuo.stds.rest.UserInfo;
import com.tusuo.stds.util.Utils;

import java.util.ArrayList;
import java.util.List;

import javax.inject.Inject;

import autodagger.AutoComponent;
import autodagger.AutoInjector;

/**
 * @author J.Huang
 * @version 1.0
 *
 */
@AutoComponent(
        dependencies = MyApp.class
)
@AutoInjector
@DaggerScope(ProvincePresenter.class)
class ProvincePresenter extends MvpBasePresenter<ProvinceView> {

    @Inject
    ApiHelper mApiHelper;
    @Inject
    CurrentUser mCurrentUser;

    private Context mContext;
    private String mErrMsgServer;

    private UserInfo mUserInfo;

    private String mStrLocation = "未知";

    private LocationClient mLocationClient = null;
    private BDLocationListener myListener = new MyLocationListener();

    ProvincePresenter(Context context, UserInfo userInfo) {
        mContext = context;
        mErrMsgServer = mContext.getResources().getString(R.string.err_msg_server);
        mUserInfo = userInfo;

        Injector.initProvincePresenterComponent().inject(this);

        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            requestLocation();
        }
    }

    @Override
    public void attachView(ProvinceView view) {
        super.attachView(view);
        if (getView() != null) {
            if (mLocationClient != null) {
                mLocationClient.start();
            }
            getView().setListViewAdapter(new AreaListAdapter(mContext, mCurrentUser.getAreaList().Data, mUserInfo, 1));
        }
    }

    @Override
    public void detachView(boolean retainInstance) {
        if (mLocationClient != null) {
            mLocationClient.stop();
        }
        super.detachView(retainInstance);
    }

    void requestLocation() {
        if (mContext instanceof ProvinceActivity_) {
            mLocationClient = new LocationClient(mContext);     //声明LocationClient类
            mLocationClient.registerLocationListener(myListener);    //注册监听函数
            initLocation();
            mLocationClient.start();
        }
    }

    private void initLocation(){
        LocationClientOption option = new LocationClientOption();
        option.setLocationMode(LocationClientOption.LocationMode.Hight_Accuracy);//可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
        option.setCoorType("bd09ll");//可选，默认gcj02，设置返回的定位结果坐标系
        option.setScanSpan(0);//可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
        option.setIsNeedAddress(true);//可选，设置是否需要地址信息，默认不需要
        option.setOpenGps(true);//可选，默认false,设置是否使用gps
        option.setLocationNotify(true);//可选，默认false，设置是否当GPS有效时按照1S/1次频率输出GPS结果
        option.setIsNeedLocationDescribe(true);//可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
        option.setIsNeedLocationPoiList(false);//可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
        option.setIgnoreKillProcess(false);//可选，默认true，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认不杀死
        option.SetIgnoreCacheException(false);//可选，默认false，设置是否收集CRASH信息，默认收集
        option.setEnableSimulateGps(true);//可选，默认false，设置是否需要过滤GPS仿真结果，默认需要
        mLocationClient.setLocOption(option);
    }

    private AreaList.Area fetchAreaFromAddr(String addr) {
        List<AreaList.Area> tempAreaList = new ArrayList<>();
        List<Integer> strIndexList = new ArrayList<>();
        // 如果一开始就匹配多个一级地址，选字符串在最前面的，比如：广东省广州市北京路
        int offset = 99999;
        int index = 0;

        if (!TextUtils.isEmpty(addr)) {
            // 省、直辖市
            for (AreaList.Area province : mCurrentUser.getAreaList().Data) {
                if (addr.contains(province.Name)) {
                    mStrLocation = province.Name;
                    // 市或区
                    for (AreaList.Area city : province.Children) {
                        if (addr.contains(city.Name)) {
                            if (province.Type == 1) {
                                return province;
                            } else {
                                mStrLocation += city.Name;
                                return city;
                            }
                        }
                    }

                    strIndexList.add(addr.indexOf(province.Name));
                    tempAreaList.add(province);
                }
            }
        }

        if (tempAreaList.size() > 0) {
            for (int i = 0;i < tempAreaList.size();i++) {
                if (offset > strIndexList.get(i)) {
                    offset = strIndexList.get(i);
                    index = i;
                }
            }

            return tempAreaList.get(index);
        } else {
            return null;
        }
    }

    private class MyLocationListener implements BDLocationListener {
        @Override
        public void onReceiveLocation(BDLocation location) {
            if (location.getLocType() == BDLocation.TypeGpsLocation){// GPS定位结果
                if (getView() != null) {
                    getView().showLocation(fetchAreaFromAddr(location.getAddrStr()), mStrLocation);
                }
            } else if (location.getLocType() == BDLocation.TypeNetWorkLocation){// 网络定位结果
                if (getView() != null) {
                    getView().showLocation(fetchAreaFromAddr(location.getAddrStr()), mStrLocation);
                }
            } else if (location.getLocType() == BDLocation.TypeOffLineLocation) {// 离线定位结果
//                sb.append("离线定位成功，离线定位结果也是有效的");
                if (getView() != null) {
                    getView().showLocation(fetchAreaFromAddr(location.getAddrStr()), mStrLocation);
                }
            } else if (location.getLocType() == BDLocation.TypeServerError) {
                Utils.UI.showToastShort("定位失败！请稍候再试");
//                sb.append("服务端网络定位失败，可以反馈IMEI号和大体定位时间到loc-bugs@baidu.com，会有人追查原因");
            } else if (location.getLocType() == BDLocation.TypeNetWorkException) {
                Utils.UI.showToastShort("网络不同导致定位失败，请检查网络是否通畅");
//                sb.append("网络不同导致定位失败，请检查网络是否通畅");
            } else if (location.getLocType() == BDLocation.TypeCriteriaException) {
//                sb.append("无法获取有效定位依据导致定位失败，一般是由于手机的原因，处于飞行模式下一般会造成这种结果，可以试着重启手机");
                Utils.UI.showToastShort("无法获取有效定位依据导致定位失败，请关闭飞行模式或重启手机");
            }
        }
    }

//    private class GetAreaListSubscriber extends Subscriber<AreaList> {
//        @Override
//        public void onCompleted() {}
//
//        @Override
//        public void onError(Throwable e) {
//            Timber.d(e.toString());
//            Utils.UI.showToastShort(mErrMsgServer);
//        }
//
//        @Override
//        public void onNext(final AreaList list) {
//            Timber.d(list.toString());
//            if (list.Total < 1 || list.Data.size()< 1) {
//                Timber.d("get area error!");
//            } else {
//                getView().setArea(list.Data, 1);
////                getView().setListViewAdapter(new AreaListAdapter(mContext, list.Data, mUserInfo, 1));
//            }
//        }
//    }
}
